#ifndef _THREAD_HPP__
#define _THREAD_HPP__


#include<iostream>
#include<string>
#include<functional>
#include<sys/types.h>
#include<unistd.h>



// verson1

namespace ThreadModule
{
	using func_t = std::function<void()>;
	static int number = 1;

	enum class TSTATUS
	{
		NEW,
		RUNNING,
		STOP
	};


	class Thread
	{
	private:
		// 不加static是成员函数，有this指针，pthread不允许有两个参数
		static void *Routine(void* args)  // void* Routine(void* this,void* args)
		{
			Thread* t = static_cast<Thread*>(args);
			t->_status = TSTATUS::RUNNING;
			t->_func(); //用来执行 _func 所代表的可调用对象

			return nullptr;
		}

		// 标记线程为分离状态
		void EnableDetach() 
		{
			_joinable = false;
		}

	public:
		Thread(func_t func):_func(func),_status(TSTATUS::NEW),_joinable(true)
		{
			_name = "Thread-" + std::to_string(number++);
			_pid = getpid();
		}

		// 启动线程
		bool Start()
		{
			if(_status != TSTATUS::RUNNING)
			{
				//pthread_create() 1.线程ID 2.线程属性(默认nullptr) 3.线程要执行的函数 4.给线程函数传数据
				int n = ::pthread_create(&_tid,nullptr,Routine,this);
				if(n != 0) return false;				
				return true;
			}
			return false;
		}

		// 停止线程
		bool Stop()
		{
			if(_status == TSTATUS::RUNNING)
			{
				int n = ::pthread_cancel(_tid);
				if(n != 0) return false;
				_status = TSTATUS::STOP;
				return true;
			}
			return false;
		}

		// 等待线程结束并回收资源
		bool Join()
		{
			if(_joinable)
			{
				int n = ::pthread_join(_tid,nullptr);
				if(n != 0) return false;
				_status = TSTATUS::STOP;
				return true;
			}
			return false;
		}

		// 分离线程
		void Detach()
		{
			EnableDetach();
			pthread_detach(_tid);
		}
		
		// 判断线程是否可连接
		bool IsJoinable()
		{
			return _joinable;
		}
		std::string Name() {return _name;}
		~Thread()
		{}
	private:
		std::string _name;
		pthread_t _tid;    // 线程ID
		pid_t _pid;        // 进程ID
		bool _joinable;    // 是否是分离的，默认不是
		func_t _func;      // 执行什么方法
		TSTATUS _status;   // 线程的状态
	};
};





// verson2

// namespace ThreadModule
// {
// 	static int number = 1;

// 	enum class TSTATUS
// 	{
// 		NEW,
// 		RUNNING,
// 		STOP
// 	};


// 	template<typename T>
// 	class Thread
// 	{
// 		using func_t = std::function<void(T)>;
// 	private:
// 		// 不加static是成员函数，有this指针，pthread不允许有两个参数
// 		static void *Routine(void* args)  // void* Routine(void* this,void* args)
// 		{
// 			Thread* t = static_cast<Thread<T>*>(args);
// 			t->_status = TSTATUS::RUNNING;
// 			t->_func(t->_data); //用来执行 _func 所代表的可调用对象

// 			return nullptr;
// 		}

// 		// 标记线程为分离状态
// 		void EnableDetach() 
// 		{
// 			_joinable = false;
// 		}

// 	public:
// 		Thread(func_t func,T data):_func(func),_data(data),_status(TSTATUS::NEW),_joinable(true)
// 		{
// 			_name = "Thread-" + std::to_string(number++);
// 			_pid = getpid();
// 		}

// 		// 启动线程
// 		bool Start()
// 		{
// 			if(_status != TSTATUS::RUNNING)
// 			{
// 				//pthread_create() 1.线程ID 2.线程属性(默认nullptr) 3.线程要执行的函数 4.给线程函数传数据
// 				int n = ::pthread_create(&_tid,nullptr,Routine,this);
// 				if(n != 0) return false;				
// 				return true;
// 			}
// 			return false;
// 		}

// 		// 停止线程
// 		bool Stop()
// 		{
// 			if(_status == TSTATUS::RUNNING)
// 			{
// 				int n = ::pthread_cancel(_tid);
// 				if(n != 0) return false;
// 				_status = TSTATUS::STOP;
// 				return true;
// 			}
// 			return false;
// 		}

// 		// 等待线程结束并回收资源
// 		bool Join()
// 		{
// 			if(_joinable)
// 			{
// 				int n = ::pthread_join(_tid,nullptr);
// 				if(n != 0) return false;
// 				_status = TSTATUS::STOP;
// 				return true;
// 			}
// 			return false;
// 		}

// 		// 分离线程
// 		void Detach()
// 		{
// 			EnableDetach();
// 			pthread_detach(_tid);
// 		}
		
// 		// 判断线程是否可连接
// 		bool IsJoinable()
// 		{
// 			return _joinable;
// 		}
// 		std::string Name() {return _name;}
// 		~Thread()
// 		{}
// 	private:
// 		std::string _name;
// 		pthread_t _tid;    // 线程ID
// 		pid_t _pid;        // 进程ID
// 		bool _joinable;    // 是否是分离的，默认不是
// 		func_t _func;      // 执行什么方法
// 		TSTATUS _status;   // 线程的状态
// 		T _data;
// 	};
// };














#endif